"""
用户名处理工具，用于智能处理用户名以适合TTS朗读
"""
import re
import random
from typing import List, Dict, Any, Optional
import unicodedata

class UsernameProcessor:
    """用户名处理器，提供各种用户名处理方法"""
    
    # 默认敏感词列表
    DEFAULT_SENSITIVE_WORDS = [
        # 极限词
        "最", "第一", "冠军", "最强", "最好", "第1", "NO.1", "no1", "top1", 
        "顶级", "天花板", "神", "大神", "王者", "霸主", "无敌",
        
        # 商业词
        "官方", "客服", "运营", "管理员", "平台", "系统", "认证",
        
        # 数字谐音敏感词
        "250", "1024", "996", "666", "233", "234", "748"
    ]
    
    # 替代称呼列表
    DEFAULT_ALTERNATIVE_NAMES = [
        "这位朋友", "这位观众", "亲爱的观众", "这位小伙伴", 
        "这位网友", "这位粉丝", "这位用户"
    ]
    
    # 平台前缀映射
    PLATFORM_PREFIXES = {
        "抖音": "",
        "快手": "",
        "微信": "",
        "网易": "",
        "哔哩": "",
        "B站": ""
    }
    
    def __init__(self, 
                 max_length: int = 8, 
                 sensitive_words: Optional[List[str]] = None,
                 alternative_names: Optional[List[str]] = None):
        """
        初始化用户名处理器
        
        @param max_length: 用户名最大长度
        @param sensitive_words: 敏感词列表，如果为None则使用默认列表
        @param alternative_names: 替代称呼列表，如果为None则使用默认列表
        """
        self.max_length = max_length
        self.sensitive_words = sensitive_words or self.DEFAULT_SENSITIVE_WORDS
        self.alternative_names = alternative_names or self.DEFAULT_ALTERNATIVE_NAMES
    
    def process(self, username: str) -> str:
        """
        处理用户名，使其适合TTS朗读
        
        @param username: 原始用户名
        @return: 处理后的用户名
        """
        if not username or len(username.strip()) == 0:
            return self._get_random_alternative()
        
        # 1. 去除平台前缀
        username = self._remove_platform_prefix(username)
        
        # 2. 去除表情符号和方括号内容
        username = self._remove_emojis(username)
        
        # 3. 如果用户名包含中文和其他字符，只保留中文部分
        username = self._extract_chinese(username)
        
        # 4. 处理英文+数字混合情况
        username = self._process_alphanumeric(username)
        
        # 5. 过滤特殊符号
        username = self._remove_special_chars(username)
        
        # 6. 过滤敏感词
        username = self._filter_sensitive_words(username)
        
        # 7. 特殊情况处理
        if not username or len(username.strip()) == 0:
            return self._get_random_alternative()
        
        # 8. 控制长度
        if len(username) > self.max_length:
            username = username[:self.max_length]
        
        return username
    
    def _remove_platform_prefix(self, username: str) -> str:
        """去除平台前缀"""
        for prefix, replacement in self.PLATFORM_PREFIXES.items():
            if username.startswith(prefix):
                username = username.replace(prefix, replacement, 1)
        return username
    
    def _remove_emojis(self, username: str) -> str:
        """
        去除表情符号和方括号内容
        """
        # 去除方括号内容 [xxx]
        username = re.sub(r'\[.*?\]', '', username)
        
        # 去除Unicode表情符号
        cleaned_name = ""
        for char in username:
            if not self._is_emoji(char):
                cleaned_name += char
        
        return cleaned_name
    
    def _is_emoji(self, char: str) -> bool:
        """判断字符是否为表情符号"""
        return unicodedata.category(char)[0] == 'S' or ord(char) >= 0x1F000 and ord(char) <= 0x1FFFF
    
    def _extract_chinese(self, username: str) -> str:
        """
        从用户名中提取中文部分，如果用户名同时包含中文和其他字符，则只保留中文
        
        @param username: 原始用户名
        @return: 处理后的用户名
        """
        # 提取所有中文字符
        chinese_chars = re.findall(r'[\u4e00-\u9fa5]', username)
        
        # 如果包含中文并且不是纯中文
        if chinese_chars and len(chinese_chars) < len(username):
            # 只返回中文部分
            return ''.join(chinese_chars)
        
        # 如果是纯中文或不包含中文，直接返回原始用户名
        return username
    
    def _process_alphanumeric(self, username: str) -> str:
        """处理英文和数字混合的用户名"""
        # 英文+数字格式
        alpha_numeric_pattern = re.compile(r'^[a-zA-Z]+[0-9]+$')
        if alpha_numeric_pattern.match(username):
            alpha_part = re.match(r'^[a-zA-Z]+', username).group()
            numeric_part = re.search(r'[0-9]+$', username).group()
            
            if len(numeric_part) >= 5:
                # 如果数字部分超过5位，取后5位数字
                return numeric_part[-5:]
            else:
                # 如果数字部分不足5位，取前5个英文字母(或全部英文部分如果不足5个字母)
                return alpha_part[:5]
        
        # 数字+英文格式
        numeric_alpha_pattern = re.compile(r'^[0-9]+[a-zA-Z]+$')
        if numeric_alpha_pattern.match(username):
            numeric_part = re.match(r'^[0-9]+', username).group()
            alpha_part = re.search(r'[a-zA-Z]+$', username).group()
            
            if len(alpha_part) >= 5:
                # 如果英文部分超过5个字母，取前5个
                return alpha_part[:5]
            else:
                # 如果英文部分不足5个字母，取后5位数字
                return numeric_part[-5:] if len(numeric_part) >= 5 else numeric_part
        
        # 纯数字ID，保留最后5位
        if username.isdigit() and len(username) > 5:
            return username[-5:]
        
        # QQ/微信风格ID (11位以上纯数字)
        if username.isdigit() and len(username) >= 11:
            return self._get_random_alternative()
            
        return username
    
    def _remove_special_chars(self, username: str) -> str:
        """过滤特殊符号，只保留中文、英文和数字"""
        # 替换下划线为空格
        username = username.replace('_', ' ')
        
        # 过滤其他特殊符号
        username = re.sub(r'[^\u4e00-\u9fa5a-zA-Z0-9\s]', '', username)
        
        # 合并多个空格为一个
        username = re.sub(r'\s+', ' ', username)
        
        # 去除首尾空格
        username = username.strip()
        
        return username
    
    def _filter_sensitive_words(self, username: str) -> str:
        """过滤敏感词"""
        for word in self.sensitive_words:
            # 不区分大小写替换
            pattern = re.compile(re.escape(word), re.IGNORECASE)
            username = pattern.sub('', username)
        
        # 处理重复字符，如"啊啊啊啊啊"
        username = self._reduce_repeated_chars(username)
        
        return username
    
    def _reduce_repeated_chars(self, text: str, max_repeat: int = 2) -> str:
        """减少重复字符"""
        if not text:
            return text
            
        result = [text[0]]
        repeat_count = 1
        
        for i in range(1, len(text)):
            if text[i] == text[i-1]:
                repeat_count += 1
                if repeat_count <= max_repeat:
                    result.append(text[i])
            else:
                repeat_count = 1
                result.append(text[i])
                
        return ''.join(result)
    
    def _get_random_alternative(self) -> str:
        """获取随机替代称呼"""
        return random.choice(self.alternative_names)
    
    @classmethod
    def create_default(cls) -> 'UsernameProcessor':
        """创建使用默认配置的用户名处理器"""
        return cls()
    
    @classmethod
    def create_from_config(cls, config: Dict[str, Any]) -> 'UsernameProcessor':
        """从配置创建用户名处理器"""
        return cls(
            max_length=config.get('max_length', 8),
            sensitive_words=config.get('sensitive_words'),
            alternative_names=config.get('alternative_names')
        )


# 单例模式，便于全局访问
_default_processor = None

def get_processor() -> UsernameProcessor:
    """获取默认的用户名处理器实例"""
    global _default_processor
    if _default_processor is None:
        _default_processor = UsernameProcessor.create_default()
    return _default_processor

def process_username(username: str) -> str:
    """
    快速处理用户名，使用默认处理器
    
    @param username: 原始用户名
    @return: 处理后的用户名
    """
    return get_processor().process(username) 